home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 526-550 / disk_548 / labelmaker / labelmakerv1.5.lzh / LabelLoad.c < prev    next >
C/C++ Source or Header  |  1991-07-22  |  23KB  |  784 lines
  1. #include <exec/types.h>
  2. #include <intuition/intuition.h>
  3. #include <graphics/gfx.h>
  4. #include <iff2.h>
  5. #include <libraries/dos.h>
  6. #include <exec/memory.h>
  7. #include "LabelDef.h"
  8.  
  9. extern LONG PicWidth, PicHeight, PicLeftEdge, PicTopEdge, PicOn;
  10. extern UWORD MyColorMap[16];
  11. extern struct LabelText *FirstText;
  12. extern struct RastPort *prp;
  13.  
  14. BYTE DecomBuffer[128];
  15. UWORD WorkMap[32];
  16.  
  17. /*----------------------------------------------------------------------*
  18.  * unpacker.c Convert data from "cmpByteRun1" run compression. 11/15/85
  19.  *
  20.  * By Jerry Morrison and Steve Shaw, Electronic Arts.
  21.  * This software is in the public domain.
  22.  *
  23.  *      control bytes:
  24.  *       [0..127]   : followed by n+1 bytes of data.
  25.  *       [-1..-127] : followed by byte to be repeated (-n)+1 times.
  26.  *       -128       : NOOP.
  27.  *
  28.  * This version for the Commodore-Amiga computer.
  29.  *----------------------------------------------------------------------*/
  30.  
  31. /*----------- UnPackRow ------------------------------------------------*/
  32.  
  33. #define UGetByte()      (*source++)
  34. #define UPutByte(c)     (*dest++ = (c))
  35.  
  36. /* Given POINTERS to POINTER variables, unpacks one row, updating the source
  37.  * and destination pointers until it produces dstBytes bytes. */
  38. BOOL UnPackRow(pSource, pDest, srcBytes0, dstBytes0)
  39.         BYTE **pSource, **pDest;  WORD srcBytes0, dstBytes0; {
  40.     register BYTE *source = *pSource;
  41.     register BYTE *dest   = *pDest;
  42.     register WORD n;
  43.     register BYTE c;
  44.     register WORD srcBytes = srcBytes0, dstBytes = dstBytes0;
  45.     BOOL error = TRUE;  /* assume error until we make it through the loop */
  46.     WORD minus128 = -128;  /* get the compiler to generate a CMP.W */
  47.  
  48.     while( dstBytes > 0 )  {
  49.         if ( (srcBytes -= 1) < 0 )  goto ErrorExit;
  50.         n = UGetByte();
  51.  
  52.         if (n >= 0) {
  53.             n += 1;
  54.             if ( (srcBytes -= n) < 0 )  goto ErrorExit;
  55.             if ( (dstBytes -= n) < 0 )  goto ErrorExit;
  56.             do {  UPutByte(UGetByte());  } while (--n > 0);
  57.             }
  58.  
  59.         else if (n != minus128) {
  60.             n = -n + 1;
  61.             if ( (srcBytes -= 1) < 0 )  goto ErrorExit;
  62.             if ( (dstBytes -= n) < 0 )  goto ErrorExit;
  63.             c = UGetByte();
  64.             do {  UPutByte(c);  } while (--n > 0);
  65.             }
  66.         }
  67.     error = FALSE;      /* success! */
  68.  
  69.   ErrorExit:
  70.     *pSource = source;  *pDest = dest;
  71.     return(error);
  72.     }
  73.  
  74. /*----------------------------------------------------------------------*
  75.  * packer.c Convert data to "cmpByteRun1" run compression.     11/15/85
  76.  *
  77.  * By Jerry Morrison and Steve Shaw, Electronic Arts.
  78.  * This software is in the public domain.
  79.  *
  80.  *      control bytes:
  81.  *       [0..127]   : followed by n+1 bytes of data.
  82.  *       [-1..-127] : followed by byte to be repeated (-n)+1 times.
  83.  *       -128       : NOOP.
  84.  *
  85.  * This version for the Commodore-Amiga computer.
  86.  *----------------------------------------------------------------------*/
  87.  
  88. #define DUMP    0
  89. #define RUN     1
  90.  
  91. #define MinRun 3
  92. #define MaxRun 128
  93. #define MaxDat 128
  94.  
  95. LONG putSize;
  96. #define GetByte()       (*source++)
  97. #define PutByte(c)      { *dest++ = (c);   ++putSize; }
  98.  
  99. char buf[256];  /* [TBD] should be 128?  on stack?*/
  100.  
  101. BYTE *PutDump(dest, nn)  BYTE *dest;  int nn; {
  102.         int i;
  103.  
  104.         PutByte(nn-1);
  105.         for(i = 0;  i < nn;  i++)   PutByte(buf[i]);
  106.         return(dest);
  107.         }
  108.  
  109. BYTE *PutRun(dest, nn, cc)   BYTE *dest;  int nn, cc; {
  110.         PutByte(-(nn-1));
  111.         PutByte(cc);
  112.         return(dest);
  113.         }
  114.  
  115. #define OutDump(nn)   dest = PutDump(dest, nn)
  116. #define OutRun(nn,cc) dest = PutRun(dest, nn, cc)
  117.  
  118. /*----------- PackRow --------------------------------------------------*/
  119. /* Given POINTERS TO POINTERS, packs one row, updating the source and
  120.    destination pointers.  RETURNs count of packed bytes.*/
  121. LONG PackRow(pSource, pDest, rowSize)
  122.     BYTE **pSource, **pDest;   LONG rowSize; {
  123.     BYTE *source, *dest;
  124.     char c,lastc = '\0';
  125.     BOOL mode = DUMP;
  126.     short nbuf = 0;             /* number of chars in buffer */
  127.     short rstart = 0;           /* buffer index current run starts */
  128.  
  129.     source = *pSource;
  130.     dest = *pDest;
  131.     putSize = 0;
  132.     buf[0] = lastc = c = GetByte();  /* so have valid lastc */
  133.     nbuf = 1;   rowSize--;      /* since one byte eaten.*/
  134.  
  135.  
  136.     for (;  rowSize;  --rowSize) {
  137.         buf[nbuf++] = c = GetByte();
  138.         switch (mode) {
  139.                 case DUMP:
  140.                         /* If the buffer is full, write the length byte,
  141.                            then the data */
  142.                         if (nbuf>MaxDat) {
  143.                                 OutDump(nbuf-1);
  144.                                 buf[0] = c;
  145.                                 nbuf = 1;   rstart = 0;
  146.                                 break;
  147.                                 }
  148.  
  149.                         if (c == lastc) {
  150.                             if (nbuf-rstart >= MinRun) {
  151.                                 if (rstart > 0) OutDump(rstart);
  152.                                 mode = RUN;
  153.                                 }
  154.                             else if (rstart == 0)
  155.                                 mode = RUN;     /* no dump in progress,
  156.                                 so can't lose by making these 2 a run.*/
  157.                             }
  158.                         else  rstart = nbuf-1;          /* first of run */
  159.                         break;
  160.  
  161.                 case RUN: if ( (c != lastc)|| ( nbuf-rstart > MaxRun)) {
  162.                         /* output run */
  163.                         OutRun(nbuf-1-rstart,lastc);
  164.                         buf[0] = c;
  165.                         nbuf = 1; rstart = 0;
  166.                         mode = DUMP;
  167.                         }
  168.                         break;
  169.                 }
  170.  
  171.         lastc = c;
  172.         }
  173.  
  174.     switch (mode) {
  175.         case DUMP: OutDump(nbuf); break;
  176.         case RUN: OutRun(nbuf-rstart,lastc); break;
  177.         }
  178.     *pSource = source;
  179.     *pDest = dest;
  180.     return(putSize);
  181.     }
  182.  
  183. /*-------------------------------------------------------------------*/
  184.  
  185.  
  186.  
  187. CheckChunkName( ChunkName)
  188. LONG ChunkName;
  189. {
  190.  int a, b, ok;
  191.  a = 0;
  192.  ok = 1;
  193.  while (( a < 4)&&(ok == 1))
  194.    {
  195.     b = (ChunkName >> (a*8)) & 255;
  196.     ok = 0;
  197.     if (((b > 64)&&(b < 91)) || ((b > 47)&&(b < 58)))
  198.       {
  199.        ok = 1;
  200.       }
  201.     a++;
  202.    }
  203.  return( ok);
  204. }
  205.  
  206.  
  207.  
  208. LoadCMAP( fh, The_Map, Length)
  209. struct FileHandle *fh;
  210. UWORD *The_Map;
  211. LONG Length;
  212. {
  213.  int i;
  214.  UBYTE ColBuf;
  215.  
  216.  for (i=0; i < Length; i++)
  217.    {
  218.     The_Map[i] = 0;
  219.     Read( fh, &ColBuf, 1L);
  220.     The_Map[i] = ColBuf << 4;
  221.     Read( fh, &ColBuf, 1L);
  222.     The_Map[i] = The_Map[i] | ColBuf;
  223.     Read( fh, &ColBuf, 1L);
  224.     The_Map[i] = The_Map[i] | (ColBuf >> 4);
  225.    }
  226. }
  227.  
  228.  
  229.  
  230. gatherchunks( DataFile, BitMapHeader,
  231.               CodedData, DataLength,
  232.               CodedColor, ColorLength)
  233.  
  234. struct FileHandle *DataFile;
  235. struct BMHDchunk  *BitMapHeader;
  236. BYTE **CodedData;
  237. LONG *DataLength;
  238. UWORD *CodedColor;
  239. LONG *ColorLength;
  240. {
  241.  ULONG ChunkLen = 0, accomplish = 0;
  242.  ULONG Buffer;
  243.  UWORD BufferWord;
  244.  UBYTE ColBuf, IDBuffer[5];
  245.  int fehler, i;
  246.  int a, b;
  247.  
  248.  fehler =0;
  249.  IDBuffer[4] =0;
  250.  while ((accomplish !=0xffff)&&(fehler < 10))
  251.    {
  252.     Read( DataFile, &Buffer, 4L);
  253.     Read( DataFile, &ChunkLen, 4L);
  254.     switch(Buffer)
  255.       {
  256.        case FORM: Read( DataFile, &Buffer, 4L);
  257.                   if (Buffer != ILBM)
  258.                     {
  259.                      accomplish = 0xffff;
  260.                      fehler = 12;
  261.                     }
  262.                   else
  263.                     {
  264.                      accomplish = accomplish | 0xf;
  265.                     }
  266.                   break;
  267.        case BMHD: Read( DataFile, BitMapHeader, ChunkLen);
  268.                   accomplish = accomplish | 0xf0;
  269.                   break;
  270.        case CAMG: Read( DataFile, &Buffer, 4L);
  271.                   break;
  272.        case CMAP: *ColorLength = ChunkLen/3;
  273.                   LoadCMAP( DataFile, CodedColor, *ColorLength);
  274.                   accomplish = accomplish | 0xf00;
  275.                   break;
  276.        case BODY: accomplish = accomplish | 0xf000;
  277.                   *DataLength = ChunkLen;
  278.                   if ((*CodedData = AllocMem( ChunkLen, MEMF_PUBLIC))== NULL)
  279.                     {
  280.                      accomplish = 0xffff;
  281.                      fehler = 13;
  282.                     }
  283.                   else
  284.                     {
  285.                      Read( DataFile, *CodedData, ChunkLen);
  286.                     }
  287.                   break;
  288.        case GRAB: for (i=0; i < ChunkLen; i++)
  289.                     {
  290.                      Read( DataFile, &ColBuf, 1L);
  291.                     }
  292.                   break;
  293.        case CCRT: for (i=0; i < ChunkLen; i++)
  294.                     {
  295.                      Read( DataFile, &ColBuf, 1L);
  296.                     }
  297.                   break;
  298.          default: strncpy( IDBuffer, &Buffer, 4);
  299.                   if ( CheckChunkName( Buffer) == 1)
  300.                     {
  301.                      for (i=0; i < ChunkLen; i++)
  302.                        {
  303.                         Read( DataFile, &ColBuf, 1L);
  304.                        }
  305.                      fehler++;
  306.                      if (fehler == 10) accomplish = 0xffff;
  307.                     }
  308.                   else
  309.                     {
  310.                      accomplish = 0xffff;
  311.                      fehler = 14;
  312.                     }
  313.                   break;
  314.       }
  315.    }
  316.  if (fehler < 10 )
  317.    {
  318.     fehler = 0;
  319.    }
  320.  return( fehler);
  321. }
  322.  
  323.  
  324.  
  325. DecodeILBM( OnRP, BitMapHeader, CodedMap, MapLength)
  326. struct RastPort *OnRP;
  327. struct BMHDchunk *BitMapHeader;
  328. BYTE *CodedMap;
  329. LONG MapLength;
  330. {
  331.  struct BitMap *MyBitMap;
  332.  BYTE *DecomHelp, *InCodeNOW, *BitMapPos;
  333.  PLANEPTR ActualPlanes[8];   /* 8 Planes forever ? */
  334.  LONG i, Zeile, Lage, RectHeight, RectWidth;
  335.  WORD ScreenWIP, ImageWIP;
  336.  WORD ScreenWIB, ImageWIB;
  337.  WORD ScreenHIL, ImageHIL;
  338.  WORD ScreenDIP, ImageDIP;
  339.  WORD DisplayWIB, DisplayHIL, MissTries;
  340.  WORD Still2Go;
  341.  
  342.  MyBitMap = OnRP->BitMap;
  343.  ScreenWIB = MyBitMap->BytesPerRow;
  344.  ScreenHIL = MyBitMap->Rows;
  345.  ScreenDIP = MyBitMap->Depth;
  346.  ScreenWIP = ScreenWIB * 8;
  347.  ImageHIL = BitMapHeader->Height;
  348.  ImageDIP = BitMapHeader->Depth;
  349.  ImageWIP = BitMapHeader->Width;
  350.  ImageWIB = ImageWIP/16;
  351.  if ( (ImageWIB*16) < ImageWIP ) ImageWIB++;
  352.  ImageWIB *=2;
  353.  RectWidth  = ( ImageWIP > ScreenWIP)? ScreenWIP: ImageWIP;
  354.  DisplayHIL = ( ImageHIL > ScreenHIL)? ScreenHIL: ImageHIL;
  355.  DisplayWIB = ( ImageWIB > ScreenWIB)? ScreenWIB: ImageWIB;
  356.  RectHeight = DisplayHIL;
  357.  SetAPen( OnRP, 0L);
  358.  RectFill( OnRP, 0L, 0L, RectWidth -1, RectHeight -1);
  359.  if ((BitMapHeader->Masking) == 1) ImageDIP++;   /* A Mask ! */
  360.  PicWidth  = RectWidth;
  361.  PicHeight = RectHeight;
  362.  InCodeNOW = CodedMap;
  363.  MissTries = 0;
  364.  Still2Go = 32000; /* Sorry, EA made me do it ( the WORD param) */
  365.  for (i=0; i < ScreenDIP; i++)
  366.    {
  367.     ActualPlanes[i] = MyBitMap->Planes[i];
  368.    }
  369.  for (Zeile=0; Zeile < DisplayHIL; Zeile++)
  370.    {
  371.     for (Lage=0; Lage < ImageDIP; Lage++)
  372.       {
  373.        if (((*BitMapHeader).Compression) == 1)
  374.          {
  375.           DecomHelp = DecomBuffer;
  376.           if ( UnPackRow(&InCodeNOW, &DecomHelp, Still2Go, ImageWIB) == TRUE)
  377.             {
  378.              MissTries++;
  379.             }
  380.          }
  381.        else
  382.          {
  383.           CopyMem( InCodeNOW, &DecomBuffer[0],(LONG)ImageWIB);
  384.           InCodeNOW += ImageWIB;
  385.           Still2Go  -= ImageWIB;
  386.          }
  387.        if (Lage < ScreenDIP)
  388.          {
  389.           BitMapPos = ActualPlanes[Lage] + Zeile*ScreenWIB;
  390.           CopyMem( &DecomBuffer[0], BitMapPos,(LONG)DisplayWIB);
  391.          }
  392.       }
  393.    }
  394.  return (MissTries);
  395. }
  396.  
  397.  
  398.  
  399. LoadILBM( ImageFile, WhichRP)
  400. struct FileHandle *ImageFile;
  401. struct RastPort *WhichRP;
  402. {
  403.  struct BMHDchunk  MyBMHD;
  404.  BYTE *ImageMemory;
  405.  int bruch, back;
  406.  LONG Colors, CodeLen;
  407.  LONG The_Colors;
  408.  
  409.  ImageMemory = NULL;
  410.  back = 1;
  411.  The_Colors = 1;
  412.  if ((bruch = gatherchunks( ImageFile, &MyBMHD, &ImageMemory, &CodeLen,
  413.                             &WorkMap[0], &The_Colors))==0)
  414.    {
  415.     bruch = DecodeILBM( WhichRP, &MyBMHD, ImageMemory, CodeLen);
  416.     if ( bruch == 0)
  417.       {
  418.        PicOn = 1;
  419.        if ( The_Colors > 16) The_Colors = 16;
  420.        CopyMem( &WorkMap[0], &MyColorMap[0], The_Colors * 2);
  421.        back = 0;
  422.       }
  423.     else
  424.       {
  425.        LMMessage("Picture not corretly saved.");
  426.        PicOn = 0;
  427.       }
  428.    }
  429.  else
  430.    {
  431.     LMMessage("Not a correct IFF-ILBM file.");
  432.    }
  433.  if (ImageMemory != NULL)   FreeMem( ImageMemory, CodeLen);
  434.  return( back);
  435. }
  436.  
  437.  
  438.  
  439. int
  440. LoadPicture( WhichRP, FileToActOn)
  441. struct RastPort *WhichRP;
  442. char *FileToActOn;
  443. {
  444.  struct FileHandle *ImageFile;
  445.  int bruch;
  446.  
  447.  ImageFile = NULL;
  448.  if (ImageFile = (struct FileHandle *) Open( FileToActOn, MODE_OLDFILE))
  449.    {
  450.     PointerState( 2);
  451.     bruch = LoadILBM( ImageFile, WhichRP);
  452.     Close( ImageFile);
  453.     PointerState( 0);
  454.    }
  455.  else
  456.    {
  457.     LMMessage("Unable to open that file.");
  458.     bruch = 1;
  459.    }
  460.  return( bruch);
  461. }
  462.  
  463.  
  464.  
  465. struct LabelText
  466. *LoadLabel( LabelName)
  467. BYTE *LabelName;
  468. {
  469.  struct FileHandle *fh;
  470.  struct LabelText *Back, *Help;
  471.  int ok, t;
  472.  LONG LongBuffer;
  473.  BYTE IDBuffer[5];
  474.  LONG NumOfTexts, fault, Colors;
  475.  
  476.  Back = NULL;
  477.  fh = NULL;
  478.  fault = 1;
  479.  if (fh = (struct FileHandle *) Open( LabelName, MODE_OLDFILE))
  480.    {
  481.     if ((ok = Read( fh, IDBuffer, 4L)) == 4)
  482.       {
  483.        if (strncmp( IDBuffer, "FORM", 4) == 0)
  484.          {
  485.           if ((ok = Read( fh, &LongBuffer, 4L)) == 4)
  486.             {
  487.              if ((ok = Read( fh, IDBuffer, 4L)) == 4)
  488.                {
  489.                 if (strncmp( IDBuffer, "LABL", 4) == 0)
  490.                   {
  491.                    if ((ok = Read( fh, IDBuffer, 4L)) == 4)
  492.                      {
  493.                       if (strncmp( IDBuffer, "LBLH", 4) == 0)
  494.                         {
  495.                          ok = Read( fh, &LongBuffer, 4L);
  496.                          ok = Read( fh, &PicOn, 4L);
  497.                          ok = Read( fh, &PicLeftEdge, 4L);
  498.                          ok = Read( fh, &PicTopEdge, 4L);
  499.                          ok = Read( fh, &NumOfTexts, 4L);
  500.                          if ( ok == 4)
  501.                            {
  502.                             DeleteAllTexts( FindStart( FirstText));
  503.                             FirstText = NULL;
  504.                             if ( PicOn == 1)
  505.                               {
  506.                                ok = LoadILBM( fh, prp);
  507.                               }
  508.                             else
  509.                               {
  510.                                ok = Read( fh, IDBuffer, 4L);
  511.                                ok = Read( fh, &LongBuffer, 4L);
  512.                                Colors = LongBuffer /3;
  513.                                if (strncmp( IDBuffer, "CMAP",4) ==0)
  514.                                  {
  515.                                   LoadCMAP( fh, WorkMap, Colors);
  516.                                   CopyMem( WorkMap, MyColorMap, Colors *2);
  517.                                  }
  518.                               }
  519.                             t =0;
  520.                             fault =0;
  521.                             while (( t < NumOfTexts)&&(fault == 0))
  522.                               {
  523.                                Back = LoadText( fh);
  524.                                if ( Back != NULL)
  525.                                  {
  526.                                   Back->AttrNumber = FindAttrNo(
  527.                                                         Back->FontName,
  528.                                                         Back->FontSize);
  529.                                   if (FirstText == NULL)
  530.                                     {
  531.                                      FirstText = Back;
  532.                                     }
  533.                                   else
  534.                                     {
  535.                                      if ( Back != FirstText)
  536.                                        {
  537.                                         Help = AddText( FirstText, Back);
  538.                                         if ( Help == NULL) fault =1;
  539.                                        }
  540.                                     }
  541.                                  }
  542.                                else
  543.                                  {
  544.                                   fault = 1;
  545.                                  }
  546.                                t++;
  547.                               }
  548.                             if ((Back == NULL)&&(FirstText != NULL))
  549.                               {
  550.                                DeleteAllTexts( FindStart( FirstText));
  551.                                FirstText = NULL;
  552.                               }
  553.                            }
  554.                         }
  555.                      }
  556.                   }
  557.                }
  558.             }
  559.          }
  560.       }
  561.     if (fault != 0) LMMessage("Read Error on that file.");
  562.     Close( fh);
  563.    }
  564.  else
  565.    {
  566.     LMMessage("Unable to open that file.");
  567.    }
  568.  return( Back);
  569. }
  570.  
  571.  
  572.  
  573. int
  574. SaveCMAP( fh, The_Map, Length, WrState)
  575. struct FileHandle *fh;
  576. UWORD *The_Map;
  577. LONG Length;
  578. int WrState;
  579. {
  580.  LONG LongBuffer;
  581.  BYTE ByteBuffer;
  582.  int a;
  583.  
  584.  LongBuffer = CMAP;
  585.  WrState = LMWrite( fh, &LongBuffer, 4L, WrState);
  586.  LongBuffer = 3* Length;
  587.  WrState = LMWrite( fh, &LongBuffer, 4L, WrState);
  588.  for (a=0; a < Length; a++)
  589.    {
  590.     ByteBuffer = (UBYTE) ((The_Map[a] >> 4)& 0xf0);
  591.     WrState = LMWrite( fh, &ByteBuffer, 1L, WrState);
  592.     ByteBuffer = (UBYTE) (The_Map[a] & 0xf0);
  593.     WrState = LMWrite( fh, &ByteBuffer, 1L, WrState);
  594.     ByteBuffer = (UBYTE) ((The_Map[a] << 4)& 0xf0);
  595.     WrState = LMWrite( fh, &ByteBuffer, 1L, WrState);
  596.    }
  597.  return( WrState);
  598. }
  599.  
  600.  
  601.  
  602. int
  603. SaveLabel( LabelName)
  604. char *LabelName;
  605. {
  606.  struct FileHandle *OutFile;
  607.  struct BitMap *MyMap;
  608.  ULONG  LongBuffer, VBuffer, CompactLength;
  609.  USHORT WordBuffer;
  610.  BYTE  ByteBuffer;
  611.  BYTE *RawRaster, *DecomHelp;
  612.  PLANEPTR mpl[8]; /* I said it before */
  613.  int t, a, b;
  614.  WORD ImageDIP, ImageWIB, ImageWIP, ImageHIL;
  615.  WORD ScreenWIB, ScreenDIP, ScreenHIL, ScreenWIP;
  616.  WORD Xaspect, Yaspect;
  617.  LONG Ebene, Zeile, nColors, ItsAPad, WrSt;
  618.  LONG PictureLength, FileLength;
  619.  LONG NumberOfTexts;
  620.  struct LabelText *Curr, *Back;
  621.  BYTE IDBuffer[5];
  622.  
  623.  PointerState( 2);
  624.  MyMap = prp->BitMap;
  625.  nColors = 1 << (MyMap->Depth);
  626.  if ( PicOn == 1)
  627.    {
  628.     ScreenWIB = MyMap->BytesPerRow;
  629.     ScreenHIL = MyMap->Rows;
  630.     ScreenDIP = MyMap->Depth;
  631.     ScreenWIP = ScreenWIB * 8;
  632.     ImageHIL  = PicHeight;
  633.     ImageWIP  = PicWidth;
  634.     ImageDIP  = MyMap->Depth;
  635.     ImageWIB  = (( ImageWIP % 16 ) == 0)? ImageWIP / 16: (ImageWIP/16) +1;
  636.     ImageWIB *= 2;
  637.     for(a = 0; a < ImageDIP; a++)
  638.       mpl[a] = MyMap->Planes[a];
  639.     CompactLength = 0;
  640.     for (Zeile = 0; Zeile < ImageHIL; Zeile++)
  641.       for (Ebene = 0; Ebene < ImageDIP; Ebene++)
  642.         {
  643.          RawRaster = mpl[Ebene]+ScreenWIB*Zeile;
  644.          DecomHelp = DecomBuffer;
  645.          CompactLength += PackRow( &RawRaster, &DecomHelp, ImageWIB);
  646.         }
  647.     if ((CompactLength & 1) != 0)
  648.       {
  649.        CompactLength++;
  650.        ItsAPad = 1;
  651.       }
  652.     else
  653.       {
  654.        ItsAPad = 0;
  655.       }
  656.     PictureLength = 8 + 4 +28 +(8+ 3*nColors) +8  +CompactLength;
  657.    }
  658.  else
  659.    {
  660.     PictureLength = 8 + 3*nColors;
  661.    }
  662.  Curr = FindStart( FirstText);
  663.  NumberOfTexts =0;
  664.  while ( Curr != NULL)
  665.    {
  666.     Curr = Curr->NextText;
  667.     NumberOfTexts++;
  668.    }
  669.  FileLength = 4 +8 +16 +PictureLength +
  670.               NumberOfTexts*(sizeof( struct LabelText) -4);
  671.  if (OutFile = (struct FileHandle *) Open( LabelName, MODE_NEWFILE))
  672.    {
  673.     strcpy( IDBuffer, "FORM");
  674.     WrSt = LMWrite( OutFile, &IDBuffer, 4, 1);
  675.     LongBuffer = FileLength;
  676.     WrSt = LMWrite( OutFile, &LongBuffer, 4, WrSt);
  677.     strcpy( IDBuffer, "LABL");
  678.     WrSt = LMWrite( OutFile, &IDBuffer, 4, WrSt);
  679.     strcpy( IDBuffer, "LBLH");
  680.     WrSt = LMWrite( OutFile, &IDBuffer, 4, WrSt);
  681.     LongBuffer = 16;
  682.     WrSt = LMWrite( OutFile, &LongBuffer, 4, WrSt);
  683.     LongBuffer = (PicOn == 1) ? 1: 0;
  684.     WrSt = LMWrite( OutFile, &LongBuffer, 4, WrSt);
  685.     LongBuffer = PicLeftEdge;
  686.     WrSt = LMWrite( OutFile, &LongBuffer, 4, WrSt);
  687.     LongBuffer = PicTopEdge;
  688.     WrSt = LMWrite( OutFile, &LongBuffer, 4, WrSt);
  689.     LongBuffer = NumberOfTexts;
  690.     WrSt = LMWrite( OutFile, &LongBuffer, 4, WrSt);
  691.     if ( PicOn == 1)
  692.       {
  693.        LongBuffer = FORM;
  694.        WrSt = LMWrite( OutFile, &LongBuffer, 4L, WrSt);
  695.        LongBuffer = 4 +28 +(8+ 3*nColors) +8  +CompactLength;
  696.        WrSt = LMWrite( OutFile, &LongBuffer, 4L, WrSt);
  697.        LongBuffer = ILBM;
  698.        WrSt = LMWrite( OutFile, &LongBuffer, 4L, WrSt);
  699.        LongBuffer = BMHD;
  700.        WrSt = LMWrite( OutFile, &LongBuffer, 4L, WrSt);
  701.        LongBuffer = 20;
  702.        WrSt = LMWrite( OutFile, &LongBuffer, 4L, WrSt);
  703.        WrSt = LMWrite( OutFile, &ImageWIP, 2L, WrSt);
  704.        WrSt = LMWrite( OutFile, &ImageHIL, 2L, WrSt);
  705.        LongBuffer = 0;
  706.        WrSt = LMWrite( OutFile, &LongBuffer, 4L, WrSt);
  707.        ByteBuffer = (UBYTE) ImageDIP;
  708.        WrSt = LMWrite( OutFile, &ByteBuffer, 1L, WrSt);
  709.        ByteBuffer = 2;
  710.        WrSt = LMWrite( OutFile, &ByteBuffer, 1L, WrSt);
  711.        ByteBuffer = 1;
  712.        WrSt = LMWrite( OutFile, &ByteBuffer, 1L, WrSt);
  713.        ByteBuffer = 0;
  714.        WrSt = LMWrite( OutFile, &ByteBuffer, 1L, WrSt);
  715.        WrSt = LMWrite( OutFile, &LongBuffer, 2L, WrSt);
  716.        Xaspect = 10;
  717.        Yaspect = 22;
  718.        WordBuffer = (Xaspect << 8) | Yaspect;;
  719.        WrSt = LMWrite( OutFile, &WordBuffer, 2L, WrSt);
  720.        WordBuffer = ScreenWIP;
  721.        WrSt = LMWrite( OutFile, &WordBuffer, 2L, WrSt);
  722.        WordBuffer = ScreenHIL;
  723.        WrSt = LMWrite( OutFile, &WordBuffer, 2L, WrSt);
  724.        WrSt = SaveCMAP( OutFile, MyColorMap, nColors, WrSt);
  725.        LongBuffer = BODY;
  726.        WrSt = LMWrite( OutFile, &LongBuffer, 4L, WrSt);
  727.        WrSt = LMWrite( OutFile, &CompactLength, 4L, WrSt);
  728.        for (Zeile = 0; Zeile < ImageHIL; Zeile++)
  729.          for (Ebene = 0; Ebene < ImageDIP; Ebene++)
  730.            {
  731.             RawRaster = mpl[Ebene]+ScreenWIB*Zeile;
  732.             DecomHelp = DecomBuffer;
  733.             CompactLength = PackRow( &RawRaster, &DecomHelp, ImageWIB);
  734.             WrSt = LMWrite( OutFile, DecomBuffer, CompactLength, WrSt);
  735.            }
  736.        if (ItsAPad == 1)
  737.          {
  738.           ByteBuffer = -128;
  739.           WrSt = LMWrite( OutFile, &ByteBuffer, 1L, WrSt);
  740.          }
  741.       }
  742.     else
  743.       {
  744.        WrSt = SaveCMAP( OutFile, MyColorMap, nColors, WrSt);
  745.       }
  746.     Curr = FindStart( FirstText);
  747.     t =0;
  748.     while( Curr != NULL)
  749.       {
  750.        t++;
  751.        WrSt = SaveText( OutFile, Curr);
  752.        Curr = Curr->NextText;
  753.       }
  754.     if (WrSt == -1) LMMessage("Write error on that file");
  755.     Close( OutFile);
  756.    }
  757.  else
  758.    {
  759.     LMMessage("Unable to open that file");
  760.    }
  761.  PointerState( 0);
  762.  return( WrSt);
  763. }
  764.  
  765.  
  766.  
  767. int
  768. LMWrite( The_File, The_Data, The_Length, FormerState)
  769. struct FileHandle *The_File;
  770. BYTE *The_Data;
  771. ULONG The_Length;
  772. int FormerState;
  773. {
  774.  if (FormerState != -1)
  775.    {
  776.     FormerState = Write( The_File, The_Data, The_Length);
  777.    }
  778.  return( FormerState);
  779. }
  780.  
  781.  
  782.  
  783.  
  784.